package org.adoxx.bpmn;

import java.util.Date;
import java.util.Locale;
import java.util.Map.Entry;

import org.adoxx.pn.PetriNet;
import org.adoxx.pn.PetriNet.PL;
import org.adoxx.pn.PetriNet.TR;
import org.adoxx.pn.input.ImporterManager;
import org.adoxx.pn.simulation.PathCollector;
import org.adoxx.pn.simulation.Simulation;
import org.adoxx.pn.simulation.TraceCollector;
import org.adoxx.pn.simulation.TransitionSelectorAdoxx;
import org.adoxx.pn.simulation.data.Path;
import org.adoxx.pn.simulation.data.Trace;
import org.adoxx.pn.simulation.data.measures.Measures;
import org.adoxx.pn.simulation.handlers.impl.CostCalculator;
import org.adoxx.pn.simulation.handlers.impl.ExecutionTimeCalculator;
import org.adoxx.pn.simulation.handlers.impl.PathGeneration;
import org.adoxx.pn.simulation.handlers.impl.TraceGeneration;
import org.adoxx.pn.simulation.handlers.impl.WaitingTimeCalculator;
import org.adoxx.utils.Utils;

public class SimulationEngine {
    private boolean fullResults = false;
    
    private ImporterManager importManager = new ImporterManager();
    
    public void returnFullResults(boolean fullResults){
        this.fullResults = fullResults;
    }
    
    public String executePathAnalysis(String model, int numExecutions) throws Exception{
        String ret = "";
        PetriNet[] pnList = importManager.generateFromModel(model);
        for(PetriNet pn:pnList){
            long startingSimulationTime = new Date().getTime();
            
            Simulation simulation = new Simulation(pn);
            
            simulation.setTransitionSelector(new TransitionSelectorAdoxx(pn));
            
            TraceGeneration traceGeneration = new TraceGeneration();
            PathGeneration pathGeneration = new PathGeneration();
            ExecutionTimeCalculator executionTimeCalculator = new ExecutionTimeCalculator();
            CostCalculator costCalculator = new CostCalculator();
            WaitingTimeCalculator waitingTimeCalculator = new WaitingTimeCalculator(executionTimeCalculator); //WaitingTimeCalculator require ExecutionTimeCalculator so also in the listener the ExecutionTimeCalculator have to be specified before
            
            simulation.addSimulationListener(traceGeneration);
            simulation.addSimulationListener(pathGeneration);
            simulation.addSimulationListener(executionTimeCalculator);
            simulation.addSimulationListener(costCalculator);
            simulation.addSimulationListener(waitingTimeCalculator); //have to be defined AFTER the executionTimeCalculator listener
            
            TraceCollector traceCollector = new TraceCollector();
            PathCollector pathCollector = new PathCollector();
            
            for(int executionCounter=0;executionCounter<numExecutions;executionCounter++){
                simulation.singleRunEvent();
                
                Trace trace = traceGeneration.getTrace();
                Path path = pathGeneration.getPath();

                Measures traceMeasures = new Measures();
                traceMeasures.executionTime = executionTimeCalculator.getExecutionTime();
                traceMeasures.costs = costCalculator.getTotalCost();
                traceMeasures.waitingTimeMap = waitingTimeCalculator.getWaitingTimeMap();
                Measures pathMeasures = new Measures();
                
                traceCollector.addTrace(trace, traceMeasures);
                pathCollector.addPath(path, trace, pathMeasures);
            }
            
            traceCollector.finalizeMeasurements();
            pathCollector.finalizeMeasurements();
            long endingSimulationTime = new Date().getTime();
            long enlapsedSimulationTime = endingSimulationTime - startingSimulationTime;
            
            if(fullResults)
                ret += formatResults(traceCollector, pathCollector, pn, enlapsedSimulationTime);
            else
                ret += formatResultsLight(traceCollector, pathCollector, pn, enlapsedSimulationTime);
        }
        
        return ret;
    }
    
    private String formatResults(TraceCollector traceCollector, PathCollector pathCollector, PetriNet pn, long enlapsedSimulationTime) throws Exception{
         
         long oneDay = Utils.convertAdoxxDateTimeToMilliseconds("00:000:08:00:00");

         String ret = "<PathAnalysis modelId=\""+pn.getName()+"\">";
         
         ret += "<GeneralMeasures>";
         ret += "<EnlapsedTime>"+Utils.convertoMillisecondsToStringDateTime(enlapsedSimulationTime)+"</EnlapsedTime>";
         ret += "<AverageCosts>"+String.format(Locale.ENGLISH, "%.2f", traceCollector.totalMeasures.averageCosts)+"</AverageCosts>";
         ret += "<MaxCosts traceId=\"t."+traceCollector.totalMeasures.maxCostsId+"\">"+traceCollector.totalMeasures.maxCosts+"</MaxCosts>";
         ret += "<AverageExecutionTime>"+Utils.convertoMillisecondsToStringDateTime((int)traceCollector.totalMeasures.averageExecutionTime)+"</AverageExecutionTime>";
         ret += "<AverageExecutionsInOneDay>"+traceCollector.totalMeasures.getNumberOfExecutionIn(oneDay)+"</AverageExecutionsInOneDay>";
         ret += "<MaxExecutionTime traceId=\"t."+traceCollector.totalMeasures.maxExecutionTimeId+"\">"+Utils.convertoMillisecondsToStringDateTime(traceCollector.totalMeasures.maxExecutionTime)+"</MaxExecutionTime>";
         ret += "<MostProbablePath pathId=\"p."+pathCollector.totalMeasures.bestProbabilityId+"\">"+String.format(Locale.ENGLISH, "%.2f", pathCollector.totalMeasures.bestProbability)+"</MostProbablePath>";
         ret += "<TotalSimulations>"+traceCollector.totalMeasures.totalTraces+"</TotalSimulations>";
         ret += "<TotalTraces>"+traceCollector.traceMeasurementsMap.size()+"</TotalTraces>";
         ret += "<TotalPaths>"+pathCollector.pathMeasurementsMap.size()+"</TotalPaths>";
         ret += "</GeneralMeasures>";
         
         ret += "<Paths>";
         for(Entry<Path, Measures> entryPathMeasures:pathCollector.pathMeasurementsMap.entrySet()){
             ret += "<Path id=\"p."+entryPathMeasures.getKey().id+"\" numberOfExecutions=\""+entryPathMeasures.getValue().numberOfExecutions+"\" pathProbability=\""+String.format(Locale.ENGLISH, "%.2f", entryPathMeasures.getValue().probability)+"\" numberOfTraces=\""+pathCollector.pathTracesMap.get(entryPathMeasures.getKey()).size()+"\">";
             ret += "<Set>";
             for(Entry<TR, org.adoxx.pn.simulation.data.Path.Counter> entry:entryPathMeasures.getKey().transitionMap.entrySet()){
                 //ret += "<Object numExecutions=\""+entry.getValue().counter+"\">"+entry.getKey().description+"</Object>";
                 ret += "<Object numExecutions=\""+entry.getValue().counter+"\" step=\""+entryPathMeasures.getKey().transitionOrderMap.get(entry.getKey()).counter+"\">"+entry.getKey().description+"</Object>";
             }
             ret += "</Set>";
             ret += "</Path>";
         }
         ret += "</Paths>";
         
         ret += "<Traces>";
         for(Entry<org.adoxx.pn.simulation.data.Trace, Measures> entryTraceMeasures:traceCollector.traceMeasurementsMap.entrySet()){
             ret += "<Trace id=\"t."+entryTraceMeasures.getKey().id+"\" numberOfExecutions=\""+entryTraceMeasures.getValue().numberOfExecutions+"\" executionTime=\""+Utils.convertoMillisecondsToStringDateTime(entryTraceMeasures.getValue().executionTime)+"\" costs=\""+entryTraceMeasures.getValue().costs+"\" traceProbability=\""+String.format(Locale.ENGLISH, "%.2f", entryTraceMeasures.getValue().probability)+"\">";
             ret += "<Steps>";
             org.adoxx.pn.simulation.data.Trace.TraceNode currentTraceNode = entryTraceMeasures.getKey().startingNode;
             while(currentTraceNode!=null){
                 String objId = currentTraceNode.executedTransition.description;
                 ret += "<Object>"+objId+"</Object>";
                 currentTraceNode = currentTraceNode.nextNode;
             }
             ret += "</Steps>";
             ret += "<WaitingTimes>";
             for(Entry<PL, org.adoxx.pn.simulation.data.measures.WaitingTime> entrySet:entryTraceMeasures.getValue().waitingTimeMap.entrySet())
                 if(entrySet.getValue().getWaitingTime()>0)
                     ret += "<Object objId=\""+entrySet.getKey().description+"\">"+Utils.convertoMillisecondsToStringDateTime(entrySet.getValue().getWaitingTime())+"</Object>";
             ret += "</WaitingTimes>";
             ret += "</Trace>";
         }
         ret += "</Traces>";
         
         ret += "</PathAnalysis>";
         return ret;
    }
    
    private String formatResultsLight(TraceCollector traceCollector, PathCollector pathCollector, PetriNet pn, long enlapsedSimulationTime) throws Exception{
        
        long oneDay = Utils.convertAdoxxDateTimeToMilliseconds("00:000:08:00:00");

        String ret = "<PathAnalysis modelId=\""+pn.getName()+"\">";
        
        ret += "<GeneralMeasures>";
        ret += "<EnlapsedTime>"+Utils.convertoMillisecondsToStringDateTime(enlapsedSimulationTime)+"</EnlapsedTime>";
        ret += "<AverageCosts>"+String.format(Locale.ENGLISH, "%.2f", traceCollector.totalMeasures.averageCosts)+"</AverageCosts>";
        ret += "<MaxCosts pathId=\"p."+traceCollector.totalMeasures.maxCostsTrace.path.id+"\">"+traceCollector.totalMeasures.maxCosts+"</MaxCosts>";
        ret += "<AverageExecutionTime>"+Utils.convertoMillisecondsToStringDateTime((int)traceCollector.totalMeasures.averageExecutionTime)+"</AverageExecutionTime>";
        ret += "<AverageExecutionsInOneDay>"+traceCollector.totalMeasures.getNumberOfExecutionIn(oneDay)+"</AverageExecutionsInOneDay>";
        ret += "<MaxExecutionTime pathId=\"p."+traceCollector.totalMeasures.maxExecutionTimeTrace.path.id+"\">"+Utils.convertoMillisecondsToStringDateTime(traceCollector.totalMeasures.maxExecutionTime)+"</MaxExecutionTime>";
        ret += "<MostProbablePath pathId=\"p."+pathCollector.totalMeasures.bestProbabilityId+"\">"+String.format(Locale.ENGLISH, "%.2f", pathCollector.totalMeasures.bestProbability)+"</MostProbablePath>";
        ret += "<TotalSimulations>"+traceCollector.totalMeasures.totalTraces+"</TotalSimulations>";
        ret += "<TotalTraces>"+traceCollector.traceMeasurementsMap.size()+"</TotalTraces>";
        ret += "<TotalPaths>"+pathCollector.pathMeasurementsMap.size()+"</TotalPaths>";
        ret += "</GeneralMeasures>";
        
        ret += "<Paths>";
        for(Entry<Path, Measures> entryPathMeasures:pathCollector.pathMeasurementsMap.entrySet()){
            ret += "<Path id=\"p."+entryPathMeasures.getKey().id+"\" numberOfExecutions=\""+entryPathMeasures.getValue().numberOfExecutions+"\" pathProbability=\""+String.format(Locale.ENGLISH, "%.2f", entryPathMeasures.getValue().probability)+"\" numberOfTraces=\""+pathCollector.pathTracesMap.get(entryPathMeasures.getKey()).size()+"\">";
            ret += "<Set>";
            for(Entry<TR, org.adoxx.pn.simulation.data.Path.Counter> entry:entryPathMeasures.getKey().transitionMap.entrySet()){
                //ret += "<Object numExecutions=\""+entry.getValue().counter+"\">"+entry.getKey().description+"</Object>";
                ret += "<Object numExecutions=\""+entry.getValue().counter+"\" step=\""+entryPathMeasures.getKey().transitionOrderMap.get(entry.getKey()).counter+"\">"+entry.getKey().description+"</Object>";
            }
            ret += "</Set>";
            ret += "</Path>";
        }
        ret += "</Paths>";

        ret += "</PathAnalysis>";
        return ret;
   }
    /*
    public static void main(String[] args) {
        try {
            String bpmnUrl = "D:\\TOOLS\\eclipse\\workspace\\test\\BP2.xml";
            String bpmnModel = new String(org.adoxx.utils.IOUtils.readFile(bpmnUrl));
            SimulationEngine sm = new SimulationEngine();
            String res = sm.executePathAnalysis(bpmnModel, 1000); //100000
            System.out.println(res);
        }catch(Exception ex){ex.printStackTrace();}
    }
    */
}